﻿#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
using namespace std;
#include "Smart Pointers.h"

void TestSmartPtr1() {
	SmartPtr<int> sp1(new int);
	*sp1 = 1;

	SmartPtr<pair<string, int>> sp2(new pair<string, int>("xxxx", 1));
	sp2->first += 'y';
	sp2->second += 1;
}

void TestSmartPtr2() {
	SmartPtr<int> sp1(new int);
	SmartPtr<int> sp2 = sp1;//运行崩溃，析构两次
	//没有自定义拷贝构造函数或拷贝赋值运算符，因此编译器会生成默认的浅拷贝版本
	//sp1 和 sp2 管理了同一块内存空间，导致这块内存被析构了两次。
}

void test_auto_ptr1() {
	bit::auto_ptr<int> ap1(new int);
	bit::auto_ptr<int> ap2(ap1);
}

//void test_unique_ptr1() {
//	bit::unique_ptr<int> up1(new int);
//	bit::unique_ptr<int> up2(ap1);
//	bit::unique_ptr<int> up2 = up1;
//}

//void test_shared_ptr1() {
//	bit::shared_ptr<string> sp1(new string("xxx"));
//	bit::shared_ptr<string> sp2(sp1);
//	bit::shared_ptr<string> sp2(new string("yyy"));
//}

////该方式可能导致new失败后抛异常无法释放
//struct ListNode {
//	int val;
//	ListNode* next;
//	ListNode* prev;
//};
//void test_shared_ptr2() {
//	
//	ListNode* n1 = new ListNode;
//	ListNode* n2 = new ListNode;
//	n1->next = n2;
//	n2->prev = n1;
//}

//struct ListNode {
//	int val;
//	////节点链接时智能指针和节点指针类型不匹配
//	//ListNode* next;
//	//ListNode* prev;
//	bit::shared_ptr<ListNode> next;
//	bit::shared_ptr<ListNode> prev;
//
//	//如果节点被智能指针释放会调用析构函数
//	~ListNode() { cout << "~ListNode()" << endl; }
//};
//void test_shared_ptr2() {
//	//用智能指针管理，避免抛异常后无法释放
//	bit::shared_ptr<ListNode> n1 = new ListNode;
//	bit::shared_ptr<ListNode> n2 = new ListNode;
//	
//	//循环引用导致内存泄漏
//	n1->next = n2;
//	n2->prev = n1;
//	//n1 的引用计数 = 2（n1 本身 + n2->prev）
//	//n2 的引用计数 = 2（n2 本身 + n1->next）
//	//n2先析构。n2的引用计数2 → 1（因为n1->next仍然持有ListNode2）
//	//n2的引用计数 = 1，所以 ListNode2 不会释放。
//	//n1后析构。n1的引用计数2 → 1（因为n2->prev仍然持有ListNode1）
//	//n1的引用计数 = 1，所以 ListNode1 不会释放。
//	//最终，n1和n2被销毁了，但ListNode1被n2->prev持有；ListNode2被n1->next持有
//}

//解决方案：next和prev使用weak_ptr。即不增加引用计数
struct ListNode {
	int val;
	bit::weak_ptr<ListNode> next;
	bit::weak_ptr<ListNode> prev;


	~ListNode() { cout << "~ListNode()" << endl; }
};
void test_shared_ptr2() {
	bit::shared_ptr<ListNode> n1(new ListNode);
	bit::shared_ptr<ListNode> n2(new ListNode);
	cout << n1.use_count() << endl;
	cout << n2.use_count() << endl;
	n1->next = n2;
	n2->prev = n1;
}


//delete[]解决方法：定制删除器
template<class T>
struct DelArray {
	void operator()(T* ptr) { delete[] ptr; }
};
void test_shared_ptr3() {
	//std::shared_ptr<ListNode> sp1(new ListNode[10]);
	////new[] 需要delete[]，但shared_ptr是delete

	bit::shared_ptr<ListNode> sp1(new ListNode[3], DelArray<ListNode>());//仿函数
	bit::shared_ptr<ListNode> sp2(new ListNode[3], [](ListNode* ptr) {delete[] ptr; });//lambda
	bit::shared_ptr<FILE> sp3(fopen("Smart Pointers.cpp", "r"), [](FILE* ptr) {fclose(ptr); });//lambda
	bit::shared_ptr<ListNode> sp4(new ListNode);

}
int main() {
	//TestSmartPtr1();
	//TestSmartPtr2();
	//test_auto_ptr1();
	//test_shared_ptr1();
	//test_shared_ptr2();
	test_shared_ptr3();
	return 0;
}